package ast

func IsClassDeclaration(node Node) bool {
	_, ok := node.(*ClassDeclaration)
	return ok
}

func IsBoundsType(node Node) bool {
	_, ok := node.(*BoundsType)
	return ok
}

func IsTypeReference(node Node) bool {
	_, ok := node.(*TypeReference)
	return ok
}

func IsProjectFile(node Node) bool {
	_, ok := node.(*ProjectFile)
	return ok
}

func IsVariableDeclaration(node Node) bool {
	_, ok := node.(*VariableDeclaration)
	return ok
}

func IsCallExpression(node Node) bool {
	_, ok := node.(*CallExpression)
	return ok
}

func IsDoStatement(node Node) bool {
	_, ok := node.(*DoStatement)
	return ok
}

func IsHeader(node Node) bool {
	_, ok := node.(*Header)
	return ok
}

func IsBold(node Node) bool {
	_, ok := node.(*Bold)
	return ok
}

func IsConstructorExpression(node Node) bool {
	_, ok := node.(*ConstructorExpression)
	return ok
}

func IsForStatement(node Node) bool {
	_, ok := node.(*ForStatement)
	return ok
}

func IsParenthesizedExpression(node Node) bool {
	_, ok := node.(*ParenthesizedExpression)
	return ok
}

func IsNumber(node Node) bool {
	_, ok := node.(*Number)
	return ok
}

func IsExpressionStatement(node Node) bool {
	_, ok := node.(*ExpressionStatement)
	return ok
}

func IsArrayType(node Node) bool {
	_, ok := node.(*ArrayType)
	return ok
}

func IsParameterDeclaration(node Node) bool {
	_, ok := node.(*ParameterDeclaration)
	return ok
}

func IsPostfixUnaryExpression(node Node) bool {
	_, ok := node.(*PostfixUnaryExpression)
	return ok
}

func IsClassExpression(node Node) bool {
	_, ok := node.(*ClassExpression)
	return ok
}

func IsLink(node Node) bool {
	_, ok := node.(*Link)
	return ok
}

func IsTokenNode(node Node) bool {
	_, ok := node.(*TokenNode)
	return ok
}

func IsDeclarationStatement(node Node) bool {
	_, ok := node.(*DeclarationStatement)
	return ok
}

func IsLabeledStatement(node Node) bool {
	_, ok := node.(*LabeledStatement)
	return ok
}

func IsSourceFile(node Node) bool {
	_, ok := node.(*SourceFile)
	return ok
}

func IsFieldDeclaration(node Node) bool {
	_, ok := node.(*FieldDeclaration)
	return ok
}

func IsSelectorExpression(node Node) bool {
	_, ok := node.(*SelectorExpression)
	return ok
}

func IsThisExpression(node Node) bool {
	_, ok := node.(*ThisExpression)
	return ok
}

func IsNewObjectExpression(node Node) bool {
	_, ok := node.(*NewObjectExpression)
	return ok
}

func IsIntersectionType(node Node) bool {
	_, ok := node.(*IntersectionType)
	return ok
}

func IsListItem(node Node) bool {
	_, ok := node.(*ListItem)
	return ok
}

func IsDeprecatedTag(node Node) bool {
	_, ok := node.(*DeprecatedTag)
	return ok
}

func IsAnnotation(node Node) bool {
	_, ok := node.(*Annotation)
	return ok
}

func IsCaseBlock(node Node) bool {
	_, ok := node.(*CaseBlock)
	return ok
}

func IsLiteralExpression(node Node) bool {
	_, ok := node.(*LiteralExpression)
	return ok
}

func IsMethodDeclaration(node Node) bool {
	_, ok := node.(*MethodDeclaration)
	return ok
}

func IsElementAccessExpression(node Node) bool {
	_, ok := node.(*ElementAccessExpression)
	return ok
}

func IsDocRoot(node Node) bool {
	_, ok := node.(*DocRoot)
	return ok
}

func IsParameterTag(node Node) bool {
	_, ok := node.(*ParameterTag)
	return ok
}

func IsDocumentTypeDeclaration(node Node) bool {
	_, ok := node.(*DocumentTypeDeclaration)
	return ok
}

func IsAsExpression(node Node) bool {
	_, ok := node.(*AsExpression)
	return ok
}

func IsReturnTag(node Node) bool {
	_, ok := node.(*ReturnTag)
	return ok
}

func IsPackage(node Node) bool {
	_, ok := node.(*Package)
	return ok
}

func IsInitializerDeclaration(node Node) bool {
	_, ok := node.(*InitializerDeclaration)
	return ok
}

func IsEnumItemDeclaration(node Node) bool {
	_, ok := node.(*EnumItemDeclaration)
	return ok
}

func IsArrowExpression(node Node) bool {
	_, ok := node.(*ArrowExpression)
	return ok
}

func IsConditionalExpression(node Node) bool {
	_, ok := node.(*ConditionalExpression)
	return ok
}

func IsReturnStatement(node Node) bool {
	_, ok := node.(*ReturnStatement)
	return ok
}

func IsAuthorTag(node Node) bool {
	_, ok := node.(*AuthorTag)
	return ok
}

func IsHeritageClause(node Node) bool {
	_, ok := node.(*HeritageClause)
	return ok
}

func IsArrowFunctionDeclaration(node Node) bool {
	_, ok := node.(*ArrowFunctionDeclaration)
	return ok
}

func IsPrefixUnaryExpression(node Node) bool {
	_, ok := node.(*PrefixUnaryExpression)
	return ok
}

func IsEmptyStatement(node Node) bool {
	_, ok := node.(*EmptyStatement)
	return ok
}

func IsSyntaxList(node Node) bool {
	_, ok := node.(*SyntaxList)
	return ok
}

func IsConstructorDeclaration(node Node) bool {
	_, ok := node.(*ConstructorDeclaration)
	return ok
}

func IsTryStatement(node Node) bool {
	_, ok := node.(*TryStatement)
	return ok
}

func IsLineBreak(node Node) bool {
	_, ok := node.(*LineBreak)
	return ok
}

func IsInstanceAccessExpression(node Node) bool {
	_, ok := node.(*InstanceAccessExpression)
	return ok
}

func IsDocumentCallExpression(node Node) bool {
	_, ok := node.(*DocumentCallExpression)
	return ok
}

func IsPackageDeclaration(node Node) bool {
	_, ok := node.(*PackageDeclaration)
	return ok
}

func IsBodyDeclaration(node Node) bool {
	_, ok := node.(*BodyDeclaration)
	return ok
}

func IsSinceTag(node Node) bool {
	_, ok := node.(*SinceTag)
	return ok
}

func IsCaseClause(node Node) bool {
	_, ok := node.(*CaseClause)
	return ok
}

func IsBranchStatement(node Node) bool {
	_, ok := node.(*BranchStatement)
	return ok
}

func IsBoldItalic(node Node) bool {
	_, ok := node.(*BoldItalic)
	return ok
}

func IsIfStatement(node Node) bool {
	_, ok := node.(*IfStatement)
	return ok
}

func IsOrderedList(node Node) bool {
	_, ok := node.(*OrderedList)
	return ok
}

func IsAliasTag(node Node) bool {
	_, ok := node.(*AliasTag)
	return ok
}

func IsSeeTag(node Node) bool {
	_, ok := node.(*SeeTag)
	return ok
}

func IsBadDeclaration(node Node) bool {
	_, ok := node.(*BadDeclaration)
	return ok
}

func IsSuperExpression(node Node) bool {
	_, ok := node.(*SuperExpression)
	return ok
}

func IsForOfStatement(node Node) bool {
	_, ok := node.(*ForOfStatement)
	return ok
}

func IsOmittedExpression(node Node) bool {
	_, ok := node.(*OmittedExpression)
	return ok
}

func IsParagraph(node Node) bool {
	_, ok := node.(*Paragraph)
	return ok
}

func IsIdentifier(node Node) bool {
	_, ok := node.(*Identifier)
	return ok
}

func IsSwitchStatement(node Node) bool {
	_, ok := node.(*SwitchStatement)
	return ok
}

func IsVersionTag(node Node) bool {
	_, ok := node.(*VersionTag)
	return ok
}

func IsImportDeclaration(node Node) bool {
	_, ok := node.(*ImportDeclaration)
	return ok
}

func IsAnnotationDeclaration(node Node) bool {
	_, ok := node.(*AnnotationDeclaration)
	return ok
}

func IsUnorderedList(node Node) bool {
	_, ok := node.(*UnorderedList)
	return ok
}

func IsExceptionTag(node Node) bool {
	_, ok := node.(*ExceptionTag)
	return ok
}

func IsModifier(node Node) bool {
	_, ok := node.(*Modifier)
	return ok
}

func IsThrowStatement(node Node) bool {
	_, ok := node.(*ThrowStatement)
	return ok
}

func IsEnumDeclaration(node Node) bool {
	_, ok := node.(*EnumDeclaration)
	return ok
}

func IsUnionType(node Node) bool {
	_, ok := node.(*UnionType)
	return ok
}

func IsCodeLink(node Node) bool {
	_, ok := node.(*CodeLink)
	return ok
}

func IsCatchClause(node Node) bool {
	_, ok := node.(*CatchClause)
	return ok
}

func IsVersion(node Node) bool {
	_, ok := node.(*Version)
	return ok
}

func IsItalic(node Node) bool {
	_, ok := node.(*Italic)
	return ok
}

func IsNewArrayExpression(node Node) bool {
	_, ok := node.(*NewArrayExpression)
	return ok
}

func IsBlockStatement(node Node) bool {
	_, ok := node.(*BlockStatement)
	return ok
}

func IsCodeText(node Node) bool {
	_, ok := node.(*CodeText)
	return ok
}

func IsCodeBlock(node Node) bool {
	_, ok := node.(*CodeBlock)
	return ok
}

func IsInterfaceDeclaration(node Node) bool {
	_, ok := node.(*InterfaceDeclaration)
	return ok
}

func IsQualifiedExpression(node Node) bool {
	_, ok := node.(*QualifiedExpression)
	return ok
}

func IsBinaryExpression(node Node) bool {
	_, ok := node.(*BinaryExpression)
	return ok
}

func IsArrayLiteralExpression(node Node) bool {
	_, ok := node.(*ArrayLiteralExpression)
	return ok
}

func IsQualifiedName(node Node) bool {
	_, ok := node.(*QualifiedName)
	return ok
}

func IsWhileStatement(node Node) bool {
	_, ok := node.(*WhileStatement)
	return ok
}

func IsPlainText(node Node) bool {
	_, ok := node.(*PlainText)
	return ok
}

func IsTypeParameterDeclaration(node Node) bool {
	_, ok := node.(*TypeParameterDeclaration)
	return ok
}

func IsIntrinsicType(node Node) bool {
	_, ok := node.(*IntrinsicType)
	return ok
}
